home *** CD-ROM | disk | FTP | other *** search
/ QuickTime 2.0 Developer Kit / QuickTime 2.0 Developer Kit.iso / mac / MAC / Programming Stuff / Interfaces / CIncludes / MacTCP.h < prev    next >
Encoding:
C/C++ Source or Header  |  1994-11-11  |  25.9 KB  |  1,015 lines  |  [TEXT/MPS ]
  1. /*
  2.      File:        MacTCP.h
  3.  
  4.      Copyright:    © 1984-1994 by Apple Computer, Inc.
  5.                  All rights reserved.
  6.  
  7.      Version:    Universal Interfaces 2.0a3  ETO #16, MPW prerelease.  Friday, November 11, 1994. 
  8.  
  9.      Bugs?:        If you find a problem with this file, send the file and version
  10.                  information (from above) and the problem description to:
  11.  
  12.                      Internet:    apple.bugs@applelink.apple.com
  13.                      AppleLink:    APPLE.BUGS
  14.  
  15. */
  16.  
  17. #ifndef __MACTCP__
  18. #define __MACTCP__
  19.  
  20.  
  21. #ifndef __TYPES__
  22. #include <Types.h>
  23. #endif
  24. /*    #include <ConditionalMacros.h>                                */
  25.  
  26. #ifndef __APPLETALK__
  27. #include <AppleTalk.h>
  28. #endif
  29. /*    #include <OSUtils.h>                                        */
  30. /*        #include <MixedMode.h>                                    */
  31. /*        #include <Memory.h>                                        */
  32.  
  33. #ifdef __cplusplus
  34. extern "C" {
  35. #endif
  36.  
  37. #if GENERATINGPOWERPC
  38. #pragma options align=mac68k
  39. #endif
  40.  
  41. #ifdef __CFM68K__
  42. #pragma lib_export on
  43. #endif
  44.  
  45.  
  46. enum {
  47.     inProgress                    = 1,                            /* I/O in progress */
  48.     ipBadLapErr                    = -23000,                        /* bad network configuration */
  49.     ipBadCnfgErr                = -23001,                        /* bad IP configuration error */
  50.     ipNoCnfgErr                    = -23002,                        /* missing IP or LAP configuration error */
  51.     ipLoadErr                    = -23003,                        /* error in MacTCP load */
  52.     ipBadAddr                    = -23004,                        /* error in getting address */
  53.     connectionClosing            = -23005,                        /* connection is closing */
  54.     invalidLength                = -23006,
  55.     connectionExists            = -23007,                        /* request conflicts with existing connection */
  56.     connectionDoesntExist        = -23008,                        /* connection does not exist */
  57.     insufficientResources        = -23009,                        /* insufficient resources to perform request */
  58.     invalidStreamPtr            = -23010,
  59.     streamAlreadyOpen            = -23011,
  60.     connectionTerminated        = -23012,
  61.     invalidBufPtr                = -23013,
  62.     invalidRDS                    = -23014,
  63.     invalidWDS                    = -23014,
  64.     openFailed                    = -23015,
  65.     commandTimeout                = -23016,
  66.     duplicateSocket                = -23017
  67. };
  68.  
  69. /* Error codes from internal IP functions */
  70. enum {
  71.     ipDontFragErr                = -23032,                        /* Packet too large to send w/o fragmenting */
  72.     ipDestDeadErr                = -23033,                        /* destination not responding */
  73.     icmpEchoTimeoutErr            = -23035,                        /* ICMP echo timed-out */
  74.     ipNoFragMemErr                = -23036,                        /* no memory to send fragmented pkt */
  75.     ipRouteErr                    = -23037,                        /* can't route packet off-net */
  76.     nameSyntaxErr                = -23041,
  77.     cacheFault                    = -23042,
  78.     noResultProc                = -23043,
  79.     noNameServer                = -23044,
  80.     authNameErr                    = -23045,
  81.     noAnsErr                    = -23046,
  82.     dnrErr                        = -23047,
  83.     outOfMemory                    = -23048
  84. };
  85.  
  86. enum {
  87.     BYTES_16WORD                = 2,                            /* bytes per = 16, bit ip word */
  88.     BYTES_32WORD                = 4,                            /* bytes per = 32, bit ip word */
  89.     BYTES_64WORD                = 8                                /* bytes per = 64, bit ip word */
  90. };
  91.  
  92. typedef unsigned char b_8;
  93.  
  94. typedef unsigned short b_16;
  95.  
  96. typedef unsigned long b_32;
  97.  
  98. typedef b_32 ip_addr;
  99.  
  100. struct ip_addrbytes {
  101.         union {
  102.             b_32                            addr;
  103.             char                            byte[4];
  104.         }                            a;
  105. };
  106. typedef struct ip_addrbytes ip_addrbytes;
  107.  
  108. struct wdsEntry {
  109.     unsigned short                    length;                        /* length of buffer */
  110.     char                            *ptr;                        /* pointer to buffer */
  111. };
  112. typedef struct wdsEntry wdsEntry;
  113.  
  114. struct rdsEntry {
  115.     unsigned short                    length;                        /* length of buffer */
  116.     char                            *ptr;                        /* pointer to buffer */
  117. };
  118. typedef struct rdsEntry rdsEntry;
  119.  
  120. typedef unsigned long BufferPtr;
  121.  
  122. typedef unsigned long StreamPtr;
  123.  
  124.  
  125. enum {
  126.     netUnreach                    = 0,
  127.     hostUnreach                    = 1,
  128.     protocolUnreach                = 2,
  129.     portUnreach                    = 3,
  130.     fragReqd                    = 4,
  131.     sourceRouteFailed            = 5,
  132.     timeExceeded                = 6,
  133.     parmProblem                    = 7,
  134.     missingOption                = 8
  135. };
  136.  
  137. typedef unsigned short ICMPMsgType;
  138.  
  139. typedef b_16 ip_port;
  140.  
  141. struct ICMPReport {
  142.     StreamPtr                        streamPtr;
  143.     ip_addr                            localHost;
  144.     ip_port                            localPort;
  145.     ip_addr                            remoteHost;
  146.     ip_port                            remotePort;
  147.     short                            reportType;
  148.     unsigned short                    optionalAddlInfo;
  149.     unsigned long                    optionalAddlInfoPtr;
  150. };
  151. typedef struct ICMPReport ICMPReport;
  152.  
  153. typedef OSErr (*OSErrProcPtr)();
  154.  
  155. #if GENERATINGCFM
  156. typedef UniversalProcPtr OSErrUPP;
  157. #else
  158. typedef OSErrProcPtr OSErrUPP;
  159. #endif
  160.  
  161. enum {
  162.     uppOSErrProcInfo = kCStackBased
  163.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  164. };
  165.  
  166. #if GENERATINGCFM
  167. #define NewOSErrProc(userRoutine)        \
  168.         (OSErrUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppOSErrProcInfo, GetCurrentArchitecture())
  169. #else
  170. #define NewOSErrProc(userRoutine)        \
  171.         ((OSErrUPP) (userRoutine))
  172. #endif
  173.  
  174. #if GENERATINGCFM
  175. #define CallOSErrProc(userRoutine)        \
  176.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppOSErrProcInfo)
  177. #else
  178. #define CallOSErrProc(userRoutine)        \
  179.         (*(userRoutine))()
  180. #endif
  181.  
  182. typedef Ptr (*PtrProcPtr)();
  183.  
  184. #if GENERATINGCFM
  185. typedef UniversalProcPtr PtrUPP;
  186. #else
  187. typedef PtrProcPtr PtrUPP;
  188. #endif
  189.  
  190. enum {
  191.     uppPtrProcInfo = kCStackBased
  192.          | RESULT_SIZE(SIZE_CODE(sizeof(Ptr)))
  193. };
  194.  
  195. #if GENERATINGCFM
  196. #define NewPtrProc(userRoutine)        \
  197.         (PtrUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppPtrProcInfo, GetCurrentArchitecture())
  198. #else
  199. #define NewPtrProc(userRoutine)        \
  200.         ((PtrUPP) (userRoutine))
  201. #endif
  202.  
  203. #if GENERATINGCFM
  204. #define CallPtrProc(userRoutine)        \
  205.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppPtrProcInfo)
  206. #else
  207. #define CallPtrProc(userRoutine)        \
  208.         (*(userRoutine))()
  209. #endif
  210.  
  211. typedef Boolean (*BooleanProcPtr)();
  212.  
  213. #if GENERATINGCFM
  214. typedef UniversalProcPtr BooleanUPP;
  215. #else
  216. typedef BooleanProcPtr BooleanUPP;
  217. #endif
  218.  
  219. enum {
  220.     uppBooleanProcInfo = kCStackBased
  221.          | RESULT_SIZE(SIZE_CODE(sizeof(Boolean)))
  222. };
  223.  
  224. #if GENERATINGCFM
  225. #define NewBooleanProc(userRoutine)        \
  226.         (BooleanUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppBooleanProcInfo, GetCurrentArchitecture())
  227. #else
  228. #define NewBooleanProc(userRoutine)        \
  229.         ((BooleanUPP) (userRoutine))
  230. #endif
  231.  
  232. #if GENERATINGCFM
  233. #define CallBooleanProc(userRoutine)        \
  234.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppBooleanProcInfo)
  235. #else
  236. #define CallBooleanProc(userRoutine)        \
  237.         (*(userRoutine))()
  238. #endif
  239.  
  240.  
  241. enum {
  242.     NUM_ALT_ADDRS                = 4
  243. };
  244.  
  245. struct hostInfo {
  246.     long                            rtnCode;
  247.     char                            cname[255];
  248.     UInt8                            filler;                        /* Filler for proper byte alignment     */
  249.     unsigned long                    addr[NUM_ALT_ADDRS];
  250. };
  251. typedef struct hostInfo hostInfo;
  252.  
  253.  
  254. enum {
  255.     A                            = 1,
  256.     NS                            = 2,
  257.     CNAME                        = 5,
  258.     HINFO                        = 13,
  259.     MX                            = 15
  260. };
  261.  
  262. typedef unsigned short AddrClasses;
  263.  
  264. struct HInfoRec {
  265.     char                            cpuType[30];
  266.     char                            osType[30];
  267. };
  268. typedef struct HInfoRec HInfoRec;
  269.  
  270. struct MXRec {
  271.     unsigned short                    preference;
  272.     char                            exchange[255];
  273. };
  274. typedef struct MXRec MXRec;
  275.  
  276. struct returnRec {
  277.     long                            rtnCode;
  278.     char                            cname[255];
  279.     UInt8                            filler;                        /* Filler for proper byte alignment     */
  280.         union {
  281.             unsigned long                    addr[NUM_ALT_ADDRS];
  282.             struct HInfoRec                    hinfo;
  283.             struct MXRec                    mx;
  284.         }                            rdata;
  285. };
  286. struct cacheEntryRecord {
  287.     char                            *cname;
  288.     unsigned short                    ctype;
  289.     unsigned short                    cacheClass;
  290.     unsigned long                    ttl;
  291.         union {
  292.             char                            *name;
  293.             ip_addr                            addr;
  294.         }                            rdata;
  295. };
  296. typedef struct returnRec returnRec;
  297.  
  298. typedef struct cacheEntryRecord cacheEntryRecord;
  299.  
  300. typedef pascal void (*EnumResultProcPtr)(struct cacheEntryRecord *cacheEntryRecordPtr, char *userDataPtr);
  301.  
  302. #if GENERATINGCFM
  303. typedef UniversalProcPtr EnumResultUPP;
  304. #else
  305. typedef EnumResultProcPtr EnumResultUPP;
  306. #endif
  307.  
  308. enum {
  309.     uppEnumResultProcInfo = kPascalStackBased
  310.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(struct cacheEntryRecord*)))
  311.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(char*)))
  312. };
  313.  
  314. #if GENERATINGCFM
  315. #define NewEnumResultProc(userRoutine)        \
  316.         (EnumResultUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppEnumResultProcInfo, GetCurrentArchitecture())
  317. #else
  318. #define NewEnumResultProc(userRoutine)        \
  319.         ((EnumResultUPP) (userRoutine))
  320. #endif
  321.  
  322. #if GENERATINGCFM
  323. #define CallEnumResultProc(userRoutine, cacheEntryRecordPtr, userDataPtr)        \
  324.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppEnumResultProcInfo, (cacheEntryRecordPtr), (userDataPtr))
  325. #else
  326. #define CallEnumResultProc(userRoutine, cacheEntryRecordPtr, userDataPtr)        \
  327.         (*(userRoutine))((cacheEntryRecordPtr), (userDataPtr))
  328. #endif
  329.  
  330. typedef pascal void (*ResultProcPtr)(struct hostInfo *hostInfoPtr, char *userDataPtr);
  331.  
  332. #if GENERATINGCFM
  333. typedef UniversalProcPtr ResultUPP;
  334. #else
  335. typedef ResultProcPtr ResultUPP;
  336. #endif
  337.  
  338. enum {
  339.     uppResultProcInfo = kPascalStackBased
  340.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(struct hostInfo*)))
  341.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(char*)))
  342. };
  343.  
  344. #if GENERATINGCFM
  345. #define NewResultProc(userRoutine)        \
  346.         (ResultUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppResultProcInfo, GetCurrentArchitecture())
  347. #else
  348. #define NewResultProc(userRoutine)        \
  349.         ((ResultUPP) (userRoutine))
  350. #endif
  351.  
  352. #if GENERATINGCFM
  353. #define CallResultProc(userRoutine, hostInfoPtr, userDataPtr)        \
  354.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppResultProcInfo, (hostInfoPtr), (userDataPtr))
  355. #else
  356. #define CallResultProc(userRoutine, hostInfoPtr, userDataPtr)        \
  357.         (*(userRoutine))((hostInfoPtr), (userDataPtr))
  358. #endif
  359.  
  360. typedef pascal void (*Result2ProcPtr)(struct returnRec *returnRecPtr, char *userDataPtr);
  361.  
  362. #if GENERATINGCFM
  363. typedef UniversalProcPtr Result2UPP;
  364. #else
  365. typedef Result2ProcPtr Result2UPP;
  366. #endif
  367.  
  368. enum {
  369.     uppResult2ProcInfo = kPascalStackBased
  370.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(struct returnRec*)))
  371.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(char*)))
  372. };
  373.  
  374. #if GENERATINGCFM
  375. #define NewResult2Proc(userRoutine)        \
  376.         (Result2UPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppResult2ProcInfo, GetCurrentArchitecture())
  377. #else
  378. #define NewResult2Proc(userRoutine)        \
  379.         ((Result2UPP) (userRoutine))
  380. #endif
  381.  
  382. #if GENERATINGCFM
  383. #define CallResult2Proc(userRoutine, returnRecPtr, userDataPtr)        \
  384.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppResult2ProcInfo, (returnRecPtr), (userDataPtr))
  385. #else
  386. #define CallResult2Proc(userRoutine, returnRecPtr, userDataPtr)        \
  387.         (*(userRoutine))((returnRecPtr), (userDataPtr))
  388. #endif
  389.  
  390. extern pascal OSErr OpenResolver(char *fileName);
  391. extern pascal OSErr StrToAddr(char *hostName, struct hostInfo *hostInfoPtr, ResultUPP ResultProc, char *userDataPtr);
  392. extern pascal OSErr AddrToStr(unsigned long addr, char *addrStr);
  393. extern pascal OSErr EnumCache(EnumResultUPP enumResultProc, char *userDataPtr);
  394. extern pascal OSErr AddrToName(ip_addr addr, struct hostInfo *hostInfoPtr, ResultUPP ResultProc, char *userDataPtr);
  395. extern pascal OSErr HInfo(char *hostName, struct returnRec *returnRecPtr, Result2UPP resultProc, char *userDataPtr);
  396. extern pascal OSErr MXInfo(char *hostName, struct returnRec *returnRecPtr, Result2UPP resultProc, char *userDataPtr);
  397. extern pascal OSErr CloseResolver(void);
  398. /* csCode to get our IP address */
  399.  
  400. enum {
  401.     ipctlGetAddr                = 15
  402. };
  403.  
  404. struct GetAddrParamBlock {
  405.     struct QElem                    *qLink;
  406.     short                            qType;
  407.     short                            ioTrap;
  408.     Ptr                                ioCmdAddr;
  409.     UniversalProcPtr                ioCompletion;
  410.     OSErr                            ioResult;
  411.     StringPtr                        ioNamePtr;
  412.     short                            ioVRefNum;
  413.     short                            ioCRefNum;
  414.     short                            csCode;                        /* standard I/O header */
  415.     ip_addr                            ourAddress;                    /* our IP address */
  416.     long                            ourNetMask;                    /* our IP net mask */
  417. };
  418. typedef struct GetAddrParamBlock GetAddrParamBlock;
  419.  
  420. /* control codes */
  421.  
  422. enum {
  423.     ipctlEchoICMP                = 17,                            /* send icmp echo */
  424.     ipctlLAPStats                = 19                            /* get lap stats */
  425. };
  426.  
  427. struct ICMPParamBlock {
  428.     struct QElem                    *qLink;
  429.     short                            qType;
  430.     short                            ioTrap;
  431.     Ptr                                ioCmdAddr;
  432.     UniversalProcPtr                ioCompletion;
  433.     OSErr                            ioResult;
  434.     StringPtr                        ioNamePtr;
  435.     short                            ioVRefNum;
  436.     short                            ioCRefNum;
  437.     short                            csCode;                        /* standard I/O header */
  438.     short                            params[11];
  439.         struct {
  440.             unsigned long                    echoRequestOut;        /* time in ticks of when the echo request went out */
  441.             unsigned long                    echoReplyIn;        /* time in ticks of when the reply was received */
  442.             struct rdsEntry                    echoedData;            /* data received in responce */
  443.             Ptr                                options;
  444.             unsigned long                    userDataPtr;
  445.         }                            icmpEchoInfo;
  446. };
  447.  
  448. enum {
  449.     NBP_TABLE_SIZE                = 20,                            /* number of NBP table entries */
  450.     NBP_MAX_NAME_SIZE            = 16 + 10 + 2
  451. };
  452.  
  453. struct nbp_entry {
  454.     ip_addr                            ip_address;                    /* IP address */
  455.     AddrBlock                        at_address;                    /* matching AppleTalk address */
  456.     Boolean                            gateway;                    /* TRUE if entry for a gateway */
  457.     Boolean                            valid;                        /* TRUE if LAP address is valid */
  458.     Boolean                            probing;                    /* TRUE if NBP lookup pending */
  459.     UInt8                            afiller;                    /* Filler for proper byte alignment     */
  460.     long                            age;                        /* ticks since cache entry verified */
  461.     long                            access;                        /* ticks since last access */
  462.     char                            filler[116];                /* for internal use only !!! */
  463. };
  464. /* number of ARP table entries */
  465.  
  466. enum {
  467.     ARP_TABLE_SIZE                = 20
  468. };
  469.  
  470. struct Enet_addr {
  471.     b_16                            en_hi;
  472.     b_32                            en_lo;
  473. };
  474. typedef struct Enet_addr Enet_addr;
  475.  
  476. struct arp_entry {
  477.     short                            age;                        /* cache aging field */
  478.     b_16                            protocol;                    /* Protocol type */
  479.     ip_addr                            ip_address;                    /* IP address */
  480.     Enet_addr                        en_address;                    /* matching Ethernet address */
  481. };
  482. typedef struct arp_entry arp_entry;
  483.  
  484. /* Command codes */
  485.  
  486. enum {
  487.     TCPCreate                    = 30,
  488.     TCPPassiveOpen                = 31,
  489.     TCPActiveOpen                = 32,
  490.     TCPSend                        = 34,
  491.     TCPNoCopyRcv                = 35,
  492.     TCPRcvBfrReturn                = 36,
  493.     TCPRcv                        = 37,
  494.     TCPClose                    = 38,
  495.     TCPAbort                    = 39,
  496.     TCPStatus                    = 40,
  497.     TCPExtendedStat                = 41,
  498.     TCPRelease                    = 42,
  499.     TCPGlobalInfo                = 43,
  500.     TCPCtlMax                    = 49
  501. };
  502.  
  503. typedef void (*ICMPEchoNotifyProcPtr)(struct ICMPParamBlock *iopb);
  504.  
  505. #if GENERATINGCFM
  506. typedef UniversalProcPtr ICMPEchoNotifyUPP;
  507. #else
  508. typedef ICMPEchoNotifyProcPtr ICMPEchoNotifyUPP;
  509. #endif
  510.  
  511. enum {
  512.     uppICMPEchoNotifyProcInfo = kCStackBased
  513.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(struct ICMPParamBlock*)))
  514. };
  515.  
  516. #if GENERATINGCFM
  517. #define NewICMPEchoNotifyProc(userRoutine)        \
  518.         (ICMPEchoNotifyUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppICMPEchoNotifyProcInfo, GetCurrentArchitecture())
  519. #else
  520. #define NewICMPEchoNotifyProc(userRoutine)        \
  521.         ((ICMPEchoNotifyUPP) (userRoutine))
  522. #endif
  523.  
  524. #if GENERATINGCFM
  525. #define CallICMPEchoNotifyProc(userRoutine, iopb)        \
  526.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppICMPEchoNotifyProcInfo, (iopb))
  527. #else
  528. #define CallICMPEchoNotifyProc(userRoutine, iopb)        \
  529.         (*(userRoutine))((iopb))
  530. #endif
  531.  
  532. struct IPParamBlock {
  533.     struct QElem                    *qLink;
  534.     short                            qType;
  535.     short                            ioTrap;
  536.     Ptr                                ioCmdAddr;
  537.     UniversalProcPtr                ioCompletion;
  538.     OSErr                            ioResult;
  539.     StringPtr                        ioNamePtr;
  540.     short                            ioVRefNum;
  541.     short                            ioCRefNum;
  542.     short                            csCode;                        /* standard I/O header */
  543.         union {
  544.                 struct {
  545.                     ip_addr                            dest;        /* echo to IP address */
  546.                     wdsEntry                        data;
  547.                     short                            timeout;
  548.                     Ptr                                options;
  549.                     unsigned short                    optLength;
  550.                     ICMPEchoNotifyUPP                icmpCompletion;
  551.                     unsigned long                    userDataPtr;
  552.                 }                            IPEchoPB;
  553.                 struct {
  554.                     struct LAPStats                    *lapStatsPtr;
  555.                 }                            LAPStatsPB;
  556.         }                            csParam;
  557. };
  558. struct LAPStats {
  559.     short                            ifType;
  560.     char                            *ifString;
  561.     short                            ifMaxMTU;
  562.     long                            ifSpeed;
  563.     short                            ifPhyAddrLength;
  564.     char                            *ifPhysicalAddress;
  565.         union {
  566.             struct arp_entry                *arp_table;
  567.             struct nbp_entry                *nbp_table;
  568.         }                            AddrXlation;
  569.     short                            slotNumber;
  570. };
  571. typedef struct LAPStats LAPStats;
  572.  
  573.  
  574. enum {
  575.     TCPClosing                    = 1,
  576.     TCPULPTimeout                = 2,
  577.     TCPTerminate                = 3,
  578.     TCPDataArrival                = 4,
  579.     TCPUrgent                    = 5,
  580.     TCPICMPReceived                = 6
  581. };
  582.  
  583. typedef unsigned short TCPEventCode;
  584.  
  585.  
  586. enum {
  587.     TCPRemoteAbort                = 2,
  588.     TCPNetworkFailure            = 3,
  589.     TCPSecPrecMismatch            = 4,
  590.     TCPULPTimeoutTerminate        = 5,
  591.     TCPULPAbort                    = 6,
  592.     TCPULPClose                    = 7,
  593.     TCPServiceError                = 8
  594. };
  595.  
  596. typedef unsigned short TCPTerminationReason;
  597.  
  598. typedef pascal void (*TCPNotifyProcPtr)(StreamPtr tcpStream, unsigned short eventCode, Ptr userDataPtr, unsigned short terminReason, struct ICMPReport *icmpMsg);
  599.  
  600. #if GENERATINGCFM
  601. typedef UniversalProcPtr TCPNotifyUPP;
  602. #else
  603. typedef TCPNotifyProcPtr TCPNotifyUPP;
  604. #endif
  605.  
  606. enum {
  607.     uppTCPNotifyProcInfo = kPascalStackBased
  608.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(StreamPtr)))
  609.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(unsigned short)))
  610.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(Ptr)))
  611.          | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(unsigned short)))
  612.          | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(struct ICMPReport*)))
  613. };
  614.  
  615. #if GENERATINGCFM
  616. #define NewTCPNotifyProc(userRoutine)        \
  617.         (TCPNotifyUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppTCPNotifyProcInfo, GetCurrentArchitecture())
  618. #else
  619. #define NewTCPNotifyProc(userRoutine)        \
  620.         ((TCPNotifyUPP) (userRoutine))
  621. #endif
  622.  
  623. #if GENERATINGCFM
  624. #define CallTCPNotifyProc(userRoutine, tcpStream, eventCode, userDataPtr, terminReason, icmpMsg)        \
  625.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppTCPNotifyProcInfo, (tcpStream), (eventCode), (userDataPtr), (terminReason), (icmpMsg))
  626. #else
  627. #define CallTCPNotifyProc(userRoutine, tcpStream, eventCode, userDataPtr, terminReason, icmpMsg)        \
  628.         (*(userRoutine))((tcpStream), (eventCode), (userDataPtr), (terminReason), (icmpMsg))
  629. #endif
  630.  
  631. typedef unsigned short tcp_port;
  632.  
  633. /* ValidityFlags */
  634.  
  635. enum {
  636.     timeoutValue                = 0x80,
  637.     timeoutAction                = 0x40,
  638.     typeOfService                = 0x20,
  639.     precedence                    = 0x10
  640. };
  641.  
  642. /* TOSFlags */
  643. enum {
  644.     lowDelay                    = 0x01,
  645.     throughPut                    = 0x02,
  646.     reliability                    = 0x04
  647. };
  648.  
  649. struct TCPCreatePB {
  650.     Ptr                                rcvBuff;
  651.     unsigned long                    rcvBuffLen;
  652.     TCPNotifyUPP                    notifyProc;
  653.     Ptr                                userDataPtr;
  654. };
  655. typedef struct TCPCreatePB TCPCreatePB;
  656.  
  657. struct TCPOpenPB {
  658.     SInt8                            ulpTimeoutValue;
  659.     SInt8                            ulpTimeoutAction;
  660.     SInt8                            validityFlags;
  661.     SInt8                            commandTimeoutValue;
  662.     ip_addr                            remoteHost;
  663.     tcp_port                        remotePort;
  664.     ip_addr                            localHost;
  665.     tcp_port                        localPort;
  666.     SInt8                            tosFlags;
  667.     SInt8                            precedence;
  668.     Boolean                            dontFrag;
  669.     SInt8                            timeToLive;
  670.     SInt8                            security;
  671.     SInt8                            optionCnt;
  672.     SInt8                            options[40];
  673.     Ptr                                userDataPtr;
  674. };
  675. typedef struct TCPOpenPB TCPOpenPB;
  676.  
  677. struct TCPSendPB {
  678.     SInt8                            ulpTimeoutValue;
  679.     SInt8                            ulpTimeoutAction;
  680.     SInt8                            validityFlags;
  681.     UInt8                            filler;                        /* Filler for proper byte alignment     */
  682.     Boolean                            pushFlag;
  683.     Boolean                            urgentFlag;
  684.     Ptr                                wdsPtr;
  685.     unsigned long                    sendFree;
  686.     unsigned short                    sendLength;
  687.     Ptr                                userDataPtr;
  688. };
  689. typedef struct TCPSendPB TCPSendPB;
  690.  
  691. /* for receive and return rcv buff calls */
  692. struct TCPReceivePB {
  693.     SInt8                            commandTimeoutValue;
  694.     SInt8                            filler;
  695.     Boolean                            markFlag;
  696.     Boolean                            urgentFlag;
  697.     Ptr                                rcvBuff;
  698.     unsigned short                    rcvBuffLen;
  699.     Ptr                                rdsPtr;
  700.     unsigned short                    rdsLength;
  701.     unsigned short                    secondTimeStamp;
  702.     Ptr                                userDataPtr;
  703. };
  704. typedef struct TCPReceivePB TCPReceivePB;
  705.  
  706. struct TCPClosePB {
  707.     SInt8                            ulpTimeoutValue;
  708.     SInt8                            ulpTimeoutAction;
  709.     SInt8                            validityFlags;
  710.     UInt8                            filler;                        /* Filler for proper byte alignment     */
  711.     Ptr                                userDataPtr;
  712. };
  713. typedef struct TCPClosePB TCPClosePB;
  714.  
  715. struct HistoBucket {
  716.     unsigned short                    value;
  717.     unsigned long                    counter;
  718. };
  719. typedef struct HistoBucket HistoBucket;
  720.  
  721.  
  722. enum {
  723.     NumOfHistoBuckets            = 7
  724. };
  725.  
  726. struct TCPConnectionStats {
  727.     unsigned long                    dataPktsRcvd;
  728.     unsigned long                    dataPktsSent;
  729.     unsigned long                    dataPktsResent;
  730.     unsigned long                    bytesRcvd;
  731.     unsigned long                    bytesRcvdDup;
  732.     unsigned long                    bytesRcvdPastWindow;
  733.     unsigned long                    bytesSent;
  734.     unsigned long                    bytesResent;
  735.     unsigned short                    numHistoBuckets;
  736.     struct HistoBucket                sentSizeHisto[NumOfHistoBuckets];
  737.     unsigned short                    lastRTT;
  738.     unsigned short                    tmrSRTT;
  739.     unsigned short                    rttVariance;
  740.     unsigned short                    tmrRTO;
  741.     SInt8                            sendTries;
  742.     SInt8                            sourchQuenchRcvd;
  743. };
  744. typedef struct TCPConnectionStats TCPConnectionStats;
  745.  
  746. struct TCPStatusPB {
  747.     SInt8                            ulpTimeoutValue;
  748.     SInt8                            ulpTimeoutAction;
  749.     long                            unused;
  750.     ip_addr                            remoteHost;
  751.     tcp_port                        remotePort;
  752.     ip_addr                            localHost;
  753.     tcp_port                        localPort;
  754.     SInt8                            tosFlags;
  755.     SInt8                            precedence;
  756.     SInt8                            connectionState;
  757.     UInt8                            filler;                        /* Filler for proper byte alignment     */
  758.     unsigned short                    sendWindow;
  759.     unsigned short                    rcvWindow;
  760.     unsigned short                    amtUnackedData;
  761.     unsigned short                    amtUnreadData;
  762.     Ptr                                securityLevelPtr;
  763.     unsigned long                    sendUnacked;
  764.     unsigned long                    sendNext;
  765.     unsigned long                    congestionWindow;
  766.     unsigned long                    rcvNext;
  767.     unsigned long                    srtt;
  768.     unsigned long                    lastRTT;
  769.     unsigned long                    sendMaxSegSize;
  770.     struct TCPConnectionStats        *connStatPtr;
  771.     Ptr                                userDataPtr;
  772. };
  773. typedef struct TCPStatusPB TCPStatusPB;
  774.  
  775. struct TCPAbortPB {
  776.     Ptr                                userDataPtr;
  777. };
  778. typedef struct TCPAbortPB TCPAbortPB;
  779.  
  780. struct TCPParam {
  781.     unsigned long                    tcpRtoA;
  782.     unsigned long                    tcpRtoMin;
  783.     unsigned long                    tcpRtoMax;
  784.     unsigned long                    tcpMaxSegSize;
  785.     unsigned long                    tcpMaxConn;
  786.     unsigned long                    tcpMaxWindow;
  787. };
  788. typedef struct TCPParam TCPParam;
  789.  
  790. struct TCPStats {
  791.     unsigned long                    tcpConnAttempts;
  792.     unsigned long                    tcpConnOpened;
  793.     unsigned long                    tcpConnAccepted;
  794.     unsigned long                    tcpConnClosed;
  795.     unsigned long                    tcpConnAborted;
  796.     unsigned long                    tcpOctetsIn;
  797.     unsigned long                    tcpOctetsOut;
  798.     unsigned long                    tcpOctetsInDup;
  799.     unsigned long                    tcpOctetsRetrans;
  800.     unsigned long                    tcpInputPkts;
  801.     unsigned long                    tcpOutputPkts;
  802.     unsigned long                    tcpDupPkts;
  803.     unsigned long                    tcpRetransPkts;
  804. };
  805. typedef struct TCPStats TCPStats;
  806.  
  807. typedef StreamPtr *StreamPPtr;
  808.  
  809. struct TCPGlobalInfoPB {
  810.     struct TCPParam                    *tcpParamPtr;
  811.     struct TCPStats                    *tcpStatsPtr;
  812.     StreamPPtr                        tcpCDBTable[1];
  813.     Ptr                                userDataPtr;
  814.     unsigned short                    maxTCPConnections;
  815. };
  816. typedef struct TCPGlobalInfoPB TCPGlobalInfoPB;
  817.  
  818. typedef void (*TCPIOCompletionProcPtr)(struct TCPiopb *iopb);
  819.  
  820. #if GENERATINGCFM
  821. typedef UniversalProcPtr TCPIOCompletionUPP;
  822. #else
  823. typedef TCPIOCompletionProcPtr TCPIOCompletionUPP;
  824. #endif
  825.  
  826. struct TCPiopb {
  827.     char                            fill12[12];
  828.     TCPIOCompletionUPP                ioCompletion;
  829.     short                            ioResult;
  830.     char                            *ioNamePtr;
  831.     short                            ioVRefNum;
  832.     short                            ioCRefNum;
  833.     short                            csCode;
  834.     StreamPtr                        tcpStream;
  835.         union {
  836.             struct TCPCreatePB                create;
  837.             struct TCPOpenPB                open;
  838.             struct TCPSendPB                send;
  839.             struct TCPReceivePB                receive;
  840.             struct TCPClosePB                close;
  841.             struct TCPAbortPB                abort;
  842.             struct TCPStatusPB                status;
  843.             struct TCPGlobalInfoPB            globalInfo;
  844.         }                            csParam;
  845. };
  846. typedef struct TCPiopb TCPiopb;
  847.  
  848.  
  849. #if GENERATINGCFM
  850. #else
  851. #endif
  852.  
  853. enum {
  854.     uppTCPIOCompletionProcInfo = kCStackBased
  855.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(struct TCPiopb*)))
  856. };
  857.  
  858. #if GENERATINGCFM
  859. #define NewTCPIOCompletionProc(userRoutine)        \
  860.         (TCPIOCompletionUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppTCPIOCompletionProcInfo, GetCurrentArchitecture())
  861. #else
  862. #define NewTCPIOCompletionProc(userRoutine)        \
  863.         ((TCPIOCompletionUPP) (userRoutine))
  864. #endif
  865.  
  866. #if GENERATINGCFM
  867. #define CallTCPIOCompletionProc(userRoutine, iopb)        \
  868.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppTCPIOCompletionProcInfo, (iopb))
  869. #else
  870. #define CallTCPIOCompletionProc(userRoutine, iopb)        \
  871.         (*(userRoutine))((iopb))
  872. #endif
  873.  
  874.  
  875. enum {
  876.     UDPCreate                    = 20,
  877.     UDPRead                        = 21,
  878.     UDPBfrReturn                = 22,
  879.     UDPWrite                    = 23,
  880.     UDPRelease                    = 24,
  881.     UDPMaxMTUSize                = 25,
  882.     UDPStatus                    = 26,
  883.     UDPMultiCreate                = 27,
  884.     UDPMultiSend                = 28,
  885.     UDPMultiRead                = 29,
  886.     UDPCtlMax                    = 29
  887. };
  888.  
  889. enum {
  890.     UDPDataArrival                = 1,
  891.     UDPICMPReceived                = 2
  892. };
  893.  
  894. typedef unsigned short UDPEventCode;
  895.  
  896. typedef pascal void (*UDPNotifyProcPtr)(StreamPtr udpStream, unsigned short eventCode, Ptr userDataPtr, struct ICMPReport *icmpMsg);
  897.  
  898. #if GENERATINGCFM
  899. typedef UniversalProcPtr UDPNotifyUPP;
  900. #else
  901. typedef UDPNotifyProcPtr UDPNotifyUPP;
  902. #endif
  903.  
  904. enum {
  905.     uppUDPNotifyProcInfo = kPascalStackBased
  906.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(StreamPtr)))
  907.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(unsigned short)))
  908.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(Ptr)))
  909.          | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(struct ICMPReport*)))
  910. };
  911.  
  912. #if GENERATINGCFM
  913. #define NewUDPNotifyProc(userRoutine)        \
  914.         (UDPNotifyUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppUDPNotifyProcInfo, GetCurrentArchitecture())
  915. #else
  916. #define NewUDPNotifyProc(userRoutine)        \
  917.         ((UDPNotifyUPP) (userRoutine))
  918. #endif
  919.  
  920. #if GENERATINGCFM
  921. #define CallUDPNotifyProc(userRoutine, udpStream, eventCode, userDataPtr, icmpMsg)        \
  922.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppUDPNotifyProcInfo, (udpStream), (eventCode), (userDataPtr), (icmpMsg))
  923. #else
  924. #define CallUDPNotifyProc(userRoutine, udpStream, eventCode, userDataPtr, icmpMsg)        \
  925.         (*(userRoutine))((udpStream), (eventCode), (userDataPtr), (icmpMsg))
  926. #endif
  927.  
  928. typedef unsigned short udp_port;
  929.  
  930. /* for create and release calls */
  931. struct UDPCreatePB {
  932.     Ptr                                rcvBuff;
  933.     unsigned long                    rcvBuffLen;
  934.     UDPNotifyUPP                    notifyProc;
  935.     unsigned short                    localPort;
  936.     Ptr                                userDataPtr;
  937.     udp_port                        endingPort;
  938. };
  939. typedef struct UDPCreatePB UDPCreatePB;
  940.  
  941. struct UDPSendPB {
  942.     unsigned short                    reserved;
  943.     ip_addr                            remoteHost;
  944.     udp_port                        remotePort;
  945.     Ptr                                wdsPtr;
  946.     Boolean                            checkSum;
  947.     UInt8                            filler;                        /* Filler for proper byte alignment     */
  948.     unsigned short                    sendLength;
  949.     Ptr                                userDataPtr;
  950.     udp_port                        localPort;
  951. };
  952. typedef struct UDPSendPB UDPSendPB;
  953.  
  954. /* for receive and buffer return calls */
  955. struct UDPReceivePB {
  956.     unsigned short                    timeOut;
  957.     ip_addr                            remoteHost;
  958.     udp_port                        remotePort;
  959.     Ptr                                rcvBuff;
  960.     unsigned short                    rcvBuffLen;
  961.     unsigned short                    secondTimeStamp;
  962.     Ptr                                userDataPtr;
  963.     ip_addr                            destHost;                    /* only for use with multi rcv */
  964.     udp_port                        destPort;                    /* only for use with multi rcv */
  965. };
  966. typedef struct UDPReceivePB UDPReceivePB;
  967.  
  968. struct UDPMTUPB {
  969.     unsigned short                    mtuSize;
  970.     ip_addr                            remoteHost;
  971.     Ptr                                userDataPtr;
  972. };
  973. typedef void (*UDPIOCompletionProcPtr)(struct UDPiopb *iopb);
  974.  
  975. #if GENERATINGCFM
  976. typedef UniversalProcPtr UDPIOCompletionUPP;
  977. #else
  978. typedef UDPIOCompletionProcPtr UDPIOCompletionUPP;
  979. #endif
  980.  
  981. typedef struct UDPMTUPB UDPMTUPB;
  982.  
  983. struct UDPiopb {
  984.     char                            fill12[12];
  985.     UDPIOCompletionUPP                ioCompletion;
  986.     short                            ioResult;
  987.     char                            *ioNamePtr;
  988.     short                            ioVRefNum;
  989.     short                            ioCRefNum;
  990.     short                            csCode;
  991.     StreamPtr                        udpStream;
  992.         union {
  993.             struct UDPCreatePB                create;
  994.             struct UDPSendPB                send;
  995.             struct UDPReceivePB                receive;
  996.             struct UDPMTUPB                    mtu;
  997.         }                            csParam;
  998. };
  999. typedef struct UDPiopb UDPiopb;
  1000.  
  1001.  
  1002. #ifdef __CFM68K__
  1003. #pragma lib_export off
  1004. #endif
  1005.  
  1006. #if GENERATINGPOWERPC
  1007. #pragma options align=reset
  1008. #endif
  1009.  
  1010. #ifdef __cplusplus
  1011. }
  1012. #endif
  1013.  
  1014. #endif /* __MACTCP__ */
  1015.